/*
  存放一些作者和文章共同的api
*/
const mongoose = require("mongoose");
const { AuthorSchema } = require("../DBModel/Author");
const { ArticleDetailSchema } = require("../DBModel/Article");
const { DraftSchema } = require("../DBModel/Draft");

// 查询作者email是否存在，存在就返回作者信息，不存在就返回null
const isAuthorExist = async (authorEmail) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 找到作者信息
    const author = await Author.findOne({ email: authorEmail });

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorEmail);
      return null;
    }

    // 返回作者信息
    return author;
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 看看作者是否含有某个收藏夹，含有返回true，否则返回false
// 这是同步代码，否则会导致出错，异步代码无法放入if语句的判断条件中
const isCollectFolderExists = async (author, folderName) => {
  try {
    // 作者已经有同名收藏夹
    if (author.collectList.some((item) => item.folderName === folderName)) {
      console.log("作者已经有同名收藏夹", author.email, folderName);
      return true;
    } else {
      console.log("作者没有该收藏夹", author.email, folderName);
      return false;
    }
  } catch (error) {
    console.log("error", error);
    return false;
  }
};

// 获取文章详情，成功返回文章详情，失败返回 null
const getArticleDetail = async (articleId) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询文章详情
    const res = await Article.findById(articleId);

    // 查询失败时返回 null
    if (!res) {
      console.log(`未找到文章Id ${articleId}`);
      return null;
    }

    // 返回文章详情
    return res;
  } catch (error) {
    console.error("Error getting article detail:", error);
    return null;
  }
};

// 这个 deleteArticleById 函数是从articleApi.js中提取的，因为articleApi.js中有对文章的删除
// 如果从articleApi.js中提取，会导致循环依赖，所以这里直接从DBApi中提取
const deleteArticleById = async (articleId, authorId) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询并且删除文章，返回删除的文章，失败返回 null
    const res = await Article.findByIdAndDelete(articleId);

    // 查询文章失败
    if (!res) {
      console.log(`查询文章失败，articleId ${articleId}`);
      return null;
    }

    // 删除文章之后，更新作者的文章列表
    const res2 = await deleteArticleFromAuthor(authorId, articleId);

    // 删除文章失败
    if (!res2) {
      console.log(`删除文章失败，articleId ${articleId}`);
      return null;
    }

    // 返回删除的文章
    return res;
  } catch (error) {
    console.error("Error deleting article:", error);
    return null;
  }
};

// 判断文章是否存在，存在返回true，不存在返回false
const isArticleExists = async (articleId) => {
  try {
    // 使用模型
    const Article = mongoose.model("Article", ArticleDetailSchema);

    // 查询文章详情
    const res = await Article.findById(articleId);

    // 查询失败时返回 null
    if (!res) {
      console.log(`未找到文章Id ${articleId}`);
      return false;
    }

    // 返回文章详情
    return true;
  } catch (error) {
    console.error("Error getting article detail:", error);
    return false;
  }
};

// 给作者的草稿列表中添加草稿
const addDraftToAuthor = async (authorId, articleId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 这里不用查询作者是否存在，在使用这个函数之前就已经查过了

    // 给作者的草稿列表中添加草稿
    const res = await Author.updateOne(
      { email: authorId },
      { $addToSet: { drafts: articleId } },
      { new: true } // 返回更新后的作者信息
    );

    // 更新失败
    if (!res) {
      console.log(`更新作者草稿列表失败，authorId ${authorId}`);
      return null;
    }

    // 返回更新后的作者信息
    return res;
  } catch (error) {
    console.error("Error adding draft to author:", error);
    return null;
  }
};

// 从作者的草稿列表中删除对应的草稿，成功返回作者信息，失败返回 null
const deleteDraftFromAuthor = async (authorId, draftId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 这里不用查询作者是否存在，在使用这个函数之前就已经查过了

    // 从作者的草稿列表中删除对应的草稿
    const res = await Author.updateOne(
      { email: authorId },
      { $pull: { drafts: draftId } },
      { new: true } // 返回更新后的作者信息
    );

    // 更新失败
    if (!res) {
      console.log(`从作者的草稿列表中删除对应的草稿失败，authorId ${authorId}`);
      return null;
    }

    // 返回更新后的作者信息
    return res;
  } catch (error) {
    console.log("从作者的草稿列表中删除对应的草稿失败", error);
    return false;
  }
};

// 从作者的文章列表中删除文章，删除成功返回更新结果，失败返回null
const deleteArticleFromAuthor = async (authorId, articleId) => {
  try {
    // 使用模型
    const Author = mongoose.model("Author", AuthorSchema);

    // 查找作者
    const author = await isAuthorExist(authorId);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorId);
      return null;
    }

    // 文章列表中没有文章
    if (!author.articles.includes(articleId)) {
      console.log("作者文章列表中没有找到文章", authorId, articleId);
      return null;
    }

    // 更新作者文章列表
    const result = await Author.updateOne(
      { email: authorId },
      { $pull: { articles: articleId } }
    );

    // 更新失败
    if (!result.modifiedCount) {
      // modifiedCount 0表示没有更新，其他数字表示更新了多少条数据
      console.log("作者文章列表中没有找到文章", authorId, articleId);
      return null;
    }

    // 返回更新结果
    return result;
  } catch (error) {
    console.log(error);

    return null;
  }
};

// 删除草稿，成功返回true，失败返回false
const deleteDraft = async (authorId, draftId) => {
  try {
    // 使用模型
    const Draft = mongoose.model("Draft", DraftSchema);

    // 查询草稿
    const draft = await Draft.findOne({ _id: draftId });

    // 草稿不存在
    if (!draft) {
      console.log("草稿不存在", draftId);
      return false;
    }

    // 查询草稿作者
    const author = await isAuthorExist(authorId);

    // 作者不存在
    if (!author) {
      console.log("作者不存在", authorId);
      return false;
    }

    // 草稿作者不匹配
    if (!author.drafts.includes(draftId)) {
      console.log("草稿作者不匹配", authorId, draftId);
      return false;
    }

    // 删除草稿
    const result = await Draft.deleteOne({ _id: draftId });

    // 删除草稿失败
    if (!result) {
      console.log("删除草稿失败", draftId);
      return false;
    }

    // 删除作者草稿
    const deleteDraftResult = await deleteDraftFromAuthor(authorId, draftId);

    // 删除作者草稿失败
    if (!deleteDraftResult.modifiedCount) {
      console.log("删除作者草稿失败", authorId, draftId);
      return false;
    }

    // 返回true
    return true;
  } catch (error) {
    console.log("删除草稿失败", error);
    return false;
  }
};

module.exports = {
  deleteDraft, // 删除草稿
  deleteDraftFromAuthor, // 从作者的草稿列表中删除对应的草稿
  addDraftToAuthor, // 给作者的草稿列表中添加草稿
  isAuthorExist, // 判断作者是否存在
  isCollectFolderExists, // 判断作者是否含有某个收藏夹
  getArticleDetail, // 获取文章详情
  deleteArticleById, // 删除文章通过文章id
  isArticleExists, // 判断文章是否存在
  deleteArticleFromAuthor, // 从作者的文章列表中删除文章
};
